home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / apt / package.py < prev   
Text File  |  2009-09-25  |  41KB  |  1,162 lines
  1. # package.py - apt package abstraction
  2. #
  3. #  Copyright (c) 2005-2009 Canonical
  4. #
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. #
  7. #  This program is free software; you can redistribute it and/or
  8. #  modify it under the terms of the GNU General Public License as
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. #
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. #
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21. """Functionality related to packages."""
  22. import gettext
  23. import httplib
  24. import os
  25. import sys
  26. import re
  27. import socket
  28. import subprocess
  29. import urllib2
  30. import warnings
  31.  
  32. try:
  33.     from collections import Sequence
  34. except ImportError:
  35.     Sequence = object
  36.  
  37. import apt_pkg
  38. import apt.progress
  39.  
  40. __all__ = ('BaseDependency', 'Dependency', 'Origin', 'Package', 'Record',
  41.            'Version', 'VersionList')
  42.  
  43.  
  44. def _(string):
  45.     """Return the translation of the string."""
  46.     return gettext.dgettext("python-apt", string)
  47.  
  48.  
  49. def _file_is_same(path, size, md5):
  50.     """Return True if the file is the same."""
  51.     if (os.path.exists(path) and os.path.getsize(path) == size and
  52.         apt_pkg.md5sum(open(path)) == md5):
  53.         return True
  54.  
  55.  
  56. class FetchError(Exception):
  57.     """Raised when a file could not be fetched."""
  58.  
  59.  
  60. class BaseDependency(object):
  61.     """A single dependency.
  62.  
  63.     Attributes defined here:
  64.         name      - The name of the dependency
  65.         relation  - The relation (>>,>=,==,<<,<=,)
  66.         version   - The version depended on
  67.         rawtype   - The type of the dependendy (e.g. 'Recommends')
  68.         preDepend - Boolean value whether this is a pre-dependency.
  69.     """
  70.  
  71.     def __init__(self, name, rel, ver, pre, rawtype=None):
  72.         self.name = name
  73.         self.relation = rel
  74.         self.version = ver
  75.         self.preDepend = pre
  76.         self.rawtype = rawtype
  77.  
  78.     def __repr__(self):
  79.         return ('<BaseDependency: name:%r relation:%r version:%r preDepend:%r>'
  80.                 % (self.name, self.relation, self.version, self.preDepend))
  81.  
  82.  
  83. class Dependency(object):
  84.     """Represent an Or-group of dependencies.
  85.  
  86.     Attributes defined here:
  87.         or_dependencies - The possible choices
  88.     """
  89.  
  90.     def __init__(self, alternatives):
  91.         self.or_dependencies = alternatives
  92.  
  93.     def __repr__(self):
  94.         return repr(self.or_dependencies)
  95.  
  96.  
  97. class DeprecatedProperty(property):
  98.     """A property which gives DeprecationWarning on access.
  99.  
  100.     This is only used for providing the properties in Package, which have been
  101.     replaced by the ones in Version.
  102.     """
  103.  
  104.     def __init__(self, fget=None, fset=None, fdel=None, doc=None):
  105.         property.__init__(self, fget, fset, fdel, doc)
  106.         self.__doc__ = ':Deprecated: ' + (doc or fget.__doc__ or '')
  107.  
  108.     def __get__(self, obj, type=None):
  109.         if obj is not None:
  110.             warnings.warn("Accessed deprecated property %s.%s, please see the "
  111.                           "Version class for alternatives." %
  112.                            ((obj.__class__.__name__ or type.__name__),
  113.                            self.fget.func_name), DeprecationWarning, 2)
  114.         return property.__get__(self, obj, type)
  115.  
  116.  
  117. class Origin(object):
  118.     """The origin of a version.
  119.  
  120.     Attributes defined here:
  121.         archive   - The archive (eg. unstable)
  122.         component - The component (eg. main)
  123.         label     - The Label, as set in the Release file
  124.         origin    - The Origin, as set in the Release file
  125.         site      - The hostname of the site.
  126.         trusted   - Boolean value whether this is trustworthy.
  127.     """
  128.  
  129.     def __init__(self, pkg, VerFileIter):
  130.         self.archive = VerFileIter.Archive
  131.         self.component = VerFileIter.Component
  132.         self.label = VerFileIter.Label
  133.         self.origin = VerFileIter.Origin
  134.         self.site = VerFileIter.Site
  135.         self.not_automatic = VerFileIter.NotAutomatic
  136.         # check the trust
  137.         indexfile = pkg._pcache._list.FindIndex(VerFileIter)
  138.         if indexfile and indexfile.IsTrusted:
  139.             self.trusted = True
  140.         else:
  141.             self.trusted = False
  142.  
  143.     def __repr__(self):
  144.         return ("<Origin component:%r archive:%r origin:%r label:%r "
  145.                 "site:%r isTrusted:%r>") % (self.component, self.archive,
  146.                                             self.origin, self.label,
  147.                                             self.site, self.trusted)
  148.  
  149.  
  150. class Record(object):
  151.     """Represent a pkgRecord.
  152.  
  153.     It can be accessed like a dictionary and can also give the original package
  154.     record if accessed as a string.
  155.     """
  156.  
  157.     def __init__(self, record_str):
  158.         self._rec = apt_pkg.ParseSection(record_str)
  159.  
  160.     def __str__(self):
  161.         return str(self._rec)
  162.  
  163.     def __getitem__(self, key):
  164.         return self._rec[key]
  165.  
  166.     def __contains__(self, key):
  167.         return self._rec.has_key(key)
  168.  
  169.     def __iter__(self):
  170.         return iter(self._rec.keys())
  171.  
  172.     def iteritems(self):
  173.         """An iterator over the (key, value) items of the record."""
  174.         for key in self._rec.keys():
  175.             yield key, self._rec[key]
  176.  
  177.     def get(self, key, default=None):
  178.         """Return record[key] if key in record, else `default`.
  179.  
  180.         The parameter `default` must be either a string or None.
  181.         """
  182.         return self._rec.get(key, default)
  183.  
  184.     def has_key(self, key):
  185.         """deprecated form of 'key in x'."""
  186.         return self._rec.has_key(key)
  187.  
  188.  
  189. class Version(object):
  190.     """Representation of a package version.
  191.  
  192.     :since: 0.7.9
  193.     """
  194.  
  195.     def __init__(self, package, cand):
  196.         self.package = package
  197.         self._cand = cand
  198.  
  199.     def _cmp(self, other):
  200.         try:
  201.             return apt_pkg.VersionCompare(self._cand.VerStr, other.version)
  202.         except AttributeError:
  203.             return apt_pkg.VersionCompare(self._cand.VerStr, other)
  204.  
  205.     def __eq__(self, other):
  206.         try:
  207.             return self._cmp(other) == 0
  208.         except TypeError:
  209.             return NotImplemented
  210.  
  211.     def __ge__(self, other):
  212.         try:
  213.             return self._cmp(other) >= 0
  214.         except TypeError:
  215.             return NotImplemented
  216.  
  217.     def __gt__(self, other):
  218.         try:
  219.             return self._cmp(other) > 0
  220.         except TypeError:
  221.             return NotImplemented
  222.  
  223.     def __le__(self, other):
  224.         try:
  225.             return self._cmp(other) <= 0
  226.         except TypeError:
  227.             return NotImplemented
  228.  
  229.     def __lt__(self, other):
  230.         try:
  231.             return self._cmp(other) < 0
  232.         except TypeError:
  233.             return NotImplemented
  234.  
  235.     def __ne__(self, other):
  236.         try:
  237.             return self._cmp(other) != 0
  238.         except TypeError:
  239.             return NotImplemented
  240.  
  241.     def __hash__(self):
  242.         return self._cand.Hash
  243.  
  244.     def __repr__(self):
  245.         return '<Version: package:%r version:%r>' % (self.package.name,
  246.                                                      self.version)
  247.  
  248.     @property
  249.     def _records(self):
  250.         """Internal helper that moves the Records to the right position."""
  251.         if self.package._pcache._records.Lookup(self._cand.FileList[0]):
  252.             return self.package._pcache._records
  253.  
  254.     @property
  255.     def installed_size(self):
  256.         """Return the size of the package when installed."""
  257.         return self._cand.InstalledSize
  258.  
  259.     @property
  260.     def homepage(self):
  261.         """Return the homepage for the package."""
  262.         return self._records.Homepage
  263.  
  264.     @property
  265.     def size(self):
  266.         """Return the size of the package."""
  267.         return self._cand.Size
  268.  
  269.     @property
  270.     def architecture(self):
  271.         """Return the architecture of the package version."""
  272.         return self._cand.Arch
  273.  
  274.     @property
  275.     def downloadable(self):
  276.         """Return whether the version of the package is downloadable."""
  277.         return bool(self._cand.Downloadable)
  278.  
  279.     @property
  280.     def version(self):
  281.         """Return the version as a string."""
  282.         return self._cand.VerStr
  283.  
  284.     @property
  285.     def summary(self):
  286.         """Return the short description (one line summary)."""
  287.         desc_iter = self._cand.TranslatedDescription
  288.         self.package._pcache._records.Lookup(desc_iter.FileList.pop(0))
  289.         return self.package._pcache._records.ShortDesc
  290.  
  291.     @property
  292.     def raw_description(self):
  293.         """return the long description (raw)."""
  294.         return self._records.LongDesc
  295.  
  296.     @property
  297.     def section(self):
  298.         """Return the section of the package."""
  299.         return self._cand.Section
  300.  
  301.     @property
  302.     def description(self, format=True, useDots=False):
  303.         """Return the formatted long description.
  304.  
  305.         Return the formated long description according to the Debian policy
  306.         (Chapter 5.6.13).
  307.         See http://www.debian.org/doc/debian-policy/ch-controlfields.html
  308.         for more information.
  309.         """
  310.         self.summary # This does the lookup for us.
  311.         desc = ''
  312.         try:
  313.             dsc = unicode(self.package._pcache._records.LongDesc, "utf-8")
  314.         except UnicodeDecodeError, err:
  315.             return _("Invalid unicode in description for '%s' (%s). "
  316.                   "Please report.") % (self.package.name, err)
  317.  
  318.         lines = iter(dsc.split("\n"))
  319.         # Skip the first line, since its a duplication of the summary
  320.         lines.next()
  321.         for raw_line in lines:
  322.             if raw_line.strip() == ".":
  323.                 # The line is just line break
  324.                 if not desc.endswith("\n"):
  325.                     desc += "\n\n"
  326.                 continue
  327.             if raw_line.startswith("  "):
  328.                 # The line should be displayed verbatim without word wrapping
  329.                 if not desc.endswith("\n"):
  330.                     line = "\n%s\n" % raw_line[2:]
  331.                 else:
  332.                     line = "%s\n" % raw_line[2:]
  333.             elif raw_line.startswith(" "):
  334.                 # The line is part of a paragraph.
  335.                 if desc.endswith("\n") or desc == "":
  336.                     # Skip the leading white space
  337.                     line = raw_line[1:]
  338.                 else:
  339.                     line = raw_line
  340.             else:
  341.                 line = raw_line
  342.             # Add current line to the description
  343.             desc += line
  344.         return desc
  345.  
  346.     @property
  347.     def source_name(self):
  348.         """Return the name of the source package."""
  349.         try:
  350.             return self._records.SourcePkg or self.package.name
  351.         except IndexError:
  352.             return self.package.name
  353.  
  354.     @property
  355.     def priority(self):
  356.         """Return the priority of the package, as string."""
  357.         return self._cand.PriorityStr
  358.  
  359.     @property
  360.     def record(self):
  361.         """Return a Record() object for this version."""
  362.         return Record(self._records.Record)
  363.  
  364.     def get_dependencies(self, *types):
  365.         """Return a list of Dependency objects for the given types."""
  366.         depends_list = []
  367.         depends = self._cand.DependsList
  368.         for t in types:
  369.             try:
  370.                 for depVerList in depends[t]:
  371.                     base_deps = []
  372.                     for depOr in depVerList:
  373.                         base_deps.append(BaseDependency(depOr.TargetPkg.Name,
  374.                                         depOr.CompType, depOr.TargetVer,
  375.                                         (t == "PreDepends"), rawtype=t))
  376.                     depends_list.append(Dependency(base_deps))
  377.             except KeyError:
  378.                 pass
  379.         return depends_list
  380.  
  381.     @property
  382.     def dependencies(self):
  383.         """Return the dependencies of the package version."""
  384.         return self.get_dependencies("PreDepends", "Depends")
  385.  
  386.     @property
  387.     def recommends(self):
  388.         """Return the recommends of the package version."""
  389.         return self.get_dependencies("Recommends")
  390.  
  391.     @property
  392.     def origins(self):
  393.         """Return a list of origins for the package version."""
  394.         origins = []
  395.         for (verFileIter, index) in self._cand.FileList:
  396.             origins.append(Origin(self.package, verFileIter))
  397.         return origins
  398.  
  399.     @property
  400.     def filename(self):
  401.         """Return the path to the file inside the archive."""
  402.         return self._records.FileName
  403.  
  404.     @property
  405.     def md5(self):
  406.         """Return the md5sum of the binary."""
  407.         return self._records.MD5Hash
  408.  
  409.     @property
  410.     def sha1(self):
  411.         """Return the sha1sum of the binary."""
  412.         return self._records.SHA1Hash
  413.  
  414.     @property
  415.     def sha256(self):
  416.         """Return the sha1sum of the binary."""
  417.         return self._records.SHA256Hash
  418.  
  419.     def _uris(self):
  420.         """Return an iterator over all available urls."""
  421.         for (packagefile, index) in self._cand.FileList:
  422.             indexfile = self.package._pcache._list.FindIndex(packagefile)
  423.             if indexfile:
  424.                 yield indexfile.ArchiveURI(self._records.FileName)
  425.  
  426.     @property
  427.     def uris(self):
  428.         """Return a list of all available uris for the binary."""
  429.         return list(self._uris())
  430.  
  431.     @property
  432.     def uri(self):
  433.         """Return a single URI for the binary."""
  434.         return self._uris().next()
  435.  
  436.     def fetch_binary(self, destdir='', progress=None):
  437.         """Fetch the binary version of the package.
  438.  
  439.         The parameter 'destdir' specifies the directory where the package will
  440.         be fetched to.
  441.  
  442.         The parameter 'progress' may refer to an apt.progress.FetchProgress()
  443.         object. If not specified or None, apt.progress.TextFetchProgress() is
  444.         used.
  445.         """
  446.         base = os.path.basename(self._records.FileName)
  447.         destfile = os.path.join(destdir, base)
  448.         if _file_is_same(destfile, self.size, self._records.MD5Hash):
  449.             print 'Ignoring already existing file:', destfile
  450.             return
  451.         acq = apt_pkg.GetAcquire(progress or apt.progress.TextFetchProgress())
  452.         apt_pkg.GetPkgAcqFile(acq, self.uri, self._records.MD5Hash, self.size,
  453.                               base, destFile=destfile)
  454.         acq.Run()
  455.         for item in acq.Items:
  456.             if item.Status != item.StatDone:
  457.                 raise FetchError("The item %r could not be fetched: %s" %
  458.                                     (item.DestFile, item.ErrorText))
  459.         return os.path.abspath(destfile)
  460.  
  461.     def fetch_source(self, destdir="", progress=None, unpack=True):
  462.         """Get the source code of a package.
  463.  
  464.         The parameter 'destdir' specifies the directory where the source will
  465.         be fetched to.
  466.  
  467.         The parameter 'progress' may refer to an apt.progress.FetchProgress()
  468.         object. If not specified or None, apt.progress.TextFetchProgress() is
  469.         used.
  470.  
  471.         The parameter 'unpack' describes whether the source should be unpacked
  472.         (True) or not (False). By default, it is unpacked.
  473.  
  474.         If 'unpack' is True, the path to the extracted directory is returned.
  475.         Otherwise, the path to the .dsc file is returned.
  476.         """
  477.         src = apt_pkg.GetPkgSrcRecords()
  478.         acq = apt_pkg.GetAcquire(progress or apt.progress.TextFetchProgress())
  479.  
  480.         dsc = None
  481.         src.Lookup(self.package.name)
  482.         try:
  483.             while self.version != src.Version:
  484.                 src.Lookup(self.package.name)
  485.         except AttributeError:
  486.             raise ValueError("No source for %r" % self)
  487.         for md5, size, path, type in src.Files:
  488.             base = os.path.basename(path)
  489.             destfile = os.path.join(destdir, base)
  490.             if type == 'dsc':
  491.                 dsc = destfile
  492.             if os.path.exists(base) and os.path.getsize(base) == size:
  493.                 fobj = open(base)
  494.                 try:
  495.                     if apt_pkg.md5sum(fobj) == md5:
  496.                         print 'Ignoring already existing file:', destfile
  497.                         continue
  498.                 finally:
  499.                     fobj.close()
  500.             apt_pkg.GetPkgAcqFile(acq, src.Index.ArchiveURI(path), md5, size,
  501.                                   base, destFile=destfile)
  502.         acq.Run()
  503.  
  504.         for item in acq.Items:
  505.             if item.Status != item.StatDone:
  506.                 raise FetchError("The item %r could not be fetched: %s" %
  507.                                     (item.DestFile, item.ErrorText))
  508.  
  509.         if unpack:
  510.             outdir = src.Package + '-' + apt_pkg.UpstreamVersion(src.Version)
  511.             outdir = os.path.join(destdir, outdir)
  512.             subprocess.check_call(["dpkg-source", "-x", dsc, outdir])
  513.             return os.path.abspath(outdir)
  514.         else:
  515.             return os.path.abspath(dsc)
  516.  
  517.  
  518. class VersionList(Sequence):
  519.     """Provide a mapping & sequence interface to all versions of a package.
  520.  
  521.     This class can be used like a dictionary, where version strings are the
  522.     keys. It can also be used as a sequence, where integers are the keys.
  523.  
  524.     You can also convert this to a dictionary or a list, using the usual way
  525.     of dict(version_list) or list(version_list). This is useful if you need
  526.     to access the version objects multiple times, because they do not have to
  527.     be recreated this way.
  528.  
  529.     Examples ('package.versions' being a version list):
  530.         '0.7.92' in package.versions # Check whether 0.7.92 is a valid version.
  531.         package.versions[0] # Return first version or raise IndexError
  532.         package.versions[0:2] # Return a new VersionList for objects 0-2
  533.         package.versions['0.7.92'] # Return version 0.7.92 or raise KeyError
  534.         package.versions.keys() # All keys, as strings.
  535.         max(package.versions)
  536.     """
  537.  
  538.     def __init__(self, package, slice=None):
  539.         self._package = package # apt.package.Package()
  540.         self._versions = package._pkg.VersionList # [apt_pkg.Version(), ...]
  541.         if slice:
  542.             self._versions = self._versions[slice]
  543.  
  544.     def __getitem__(self, item):
  545.         if isinstance(item, slice):
  546.             return self.__class__(self._package, item)
  547.         try:
  548.             # Sequence interface, item is an integer
  549.             return Version(self._package, self._versions[item])
  550.         except TypeError:
  551.             # Dictionary interface item is a string.
  552.             for ver in self._versions:
  553.                 if ver.ver_str == item:
  554.                     return Version(self._package, ver)
  555.         raise KeyError("Version: %r not found." % (item))
  556.  
  557.     def __repr__(self):
  558.         return '<VersionList: %r>' % self.keys()
  559.  
  560.     def __iter__(self):
  561.         """Return an iterator over all value objects."""
  562.         return (Version(self._package, ver) for ver in self._versions)
  563.  
  564.     def __contains__(self, item):
  565.         if isinstance(item, Version): # Sequence interface
  566.             item = item.version
  567.         # Dictionary interface.
  568.         for ver in self._versions:
  569.             if ver.ver_str == item:
  570.                 return True
  571.         return False
  572.  
  573.     def __eq__(self, other):
  574.         return list(self) == list(other)
  575.  
  576.     def __len__(self):
  577.         return len(self._versions)
  578.  
  579.     # Mapping interface
  580.  
  581.     def keys(self):
  582.         """Return a list of all versions, as strings."""
  583.         return [ver.VerStr for ver in self._versions]
  584.  
  585.     def get(self, key, default=None):
  586.         """Return the key or the default."""
  587.         try:
  588.             return self[key]
  589.         except LookupError:
  590.             return default
  591.  
  592.  
  593. class Package(object):
  594.     """Representation of a package in a cache.
  595.  
  596.     This class provides methods and properties for working with a package. It
  597.     lets you mark the package for installation, check if it is installed, and
  598.     much more.
  599.     """
  600.  
  601.     def __init__(self, pcache, pkgiter):
  602.         """ Init the Package object """
  603.         self._pkg = pkgiter
  604.         self._pcache = pcache           # python cache in cache.py
  605.         self._changelog = ""            # Cached changelog
  606.  
  607.     def __repr__(self):
  608.         return '<Package: name:%r id:%r>' % (self._pkg.Name, self._pkg.ID)
  609.  
  610.     def candidate(self):
  611.         """Return the candidate version of the package.
  612.  
  613.         This property is writeable to allow you to set the candidate version
  614.         of the package. Just assign a Version() object, and it will be set as
  615.         the candidate version.
  616.         """
  617.         cand = self._pcache._depcache.GetCandidateVer(self._pkg)
  618.         if cand is not None:
  619.             return Version(self, cand)
  620.  
  621.     def __set_candidate(self, version):
  622.         """Set the candidate version of the package."""
  623.         self._pcache.cachePreChange()
  624.         self._pcache._depcache.SetCandidateVer(self._pkg, version._cand)
  625.         self._pcache.cachePostChange()
  626.  
  627.     candidate = property(candidate, __set_candidate)
  628.  
  629.     @property
  630.     def installed(self):
  631.         """Return the currently installed version of the package.
  632.  
  633.         :since: 0.7.9"""
  634.         if self._pkg.CurrentVer is not None:
  635.             return Version(self, self._pkg.CurrentVer)
  636.  
  637.     @property
  638.     def name(self):
  639.         """Return the name of the package."""
  640.         return self._pkg.Name
  641.  
  642.     @property
  643.     def id(self):
  644.         """Return a uniq ID for the package.
  645.  
  646.         This can be used eg. to store additional information about the pkg."""
  647.         return self._pkg.ID
  648.  
  649.     def __hash__(self):
  650.         """Return the hash of the object.
  651.  
  652.         This returns the same value as ID, which is unique."""
  653.         return self._pkg.ID
  654.  
  655.     @property
  656.     def essential(self):
  657.         """Return True if the package is an essential part of the system."""
  658.         return self._pkg.Essential
  659.  
  660.     @DeprecatedProperty
  661.     def installedVersion(self):
  662.         """Return the installed version as string.
  663.  
  664.         Deprecated, please use installed.version instead."""
  665.         return getattr(self.installed, 'version', None)
  666.  
  667.     @DeprecatedProperty
  668.     def candidateVersion(self):
  669.         """Return the candidate version as string."""
  670.         return getattr(self.candidate, "version", None)
  671.  
  672.     @DeprecatedProperty
  673.     def candidateDependencies(self):
  674.         """Return a list of candidate dependencies."""
  675.         return getattr(self.candidate, "dependencies", None)
  676.  
  677.     @DeprecatedProperty
  678.     def installedDependencies(self):
  679.         """Return a list of installed dependencies."""
  680.         return getattr(self.installed, 'dependencies', [])
  681.  
  682.     @DeprecatedProperty
  683.     def architecture(self):
  684.         """Return the Architecture of the package"""
  685.         return getattr(self.candidate, "architecture", None)
  686.  
  687.     @DeprecatedProperty
  688.     def candidateDownloadable(self):
  689.         """Return True if the candidate is downloadable."""
  690.         return getattr(self.candidate, "downloadable", None)
  691.  
  692.     @DeprecatedProperty
  693.     def installedDownloadable(self):
  694.         """Return True if the installed version is downloadable."""
  695.         return getattr(self.installed, 'downloadable', False)
  696.  
  697.     @DeprecatedProperty
  698.     def sourcePackageName(self):
  699.         """Return the source package name as string."""
  700.         try:
  701.             return self.candidate._records.SourcePkg or self._pkg.Name
  702.         except AttributeError:
  703.             try:
  704.                 return self.installed._records.SourcePkg or self._pkg.Name
  705.             except AttributeError:
  706.                 return self._pkg.Name
  707.  
  708.     @DeprecatedProperty
  709.     def homepage(self):
  710.         """Return the homepage field as string."""
  711.         return getattr(self.candidate, "homepage", None)
  712.  
  713.     @property
  714.     def section(self):
  715.         """Return the section of the package."""
  716.         return self._pkg.Section
  717.  
  718.     @DeprecatedProperty
  719.     def priority(self):
  720.         """Return the priority (of the candidate version)."""
  721.         return getattr(self.candidate, "priority", None)
  722.  
  723.     @DeprecatedProperty
  724.     def installedPriority(self):
  725.         """Return the priority (of the installed version)."""
  726.         return getattr(self.installed, 'priority', None)
  727.  
  728.     @DeprecatedProperty
  729.     def summary(self):
  730.         """Return the short description (one line summary)."""
  731.         return getattr(self.candidate, "summary", None)
  732.  
  733.     @DeprecatedProperty
  734.     def description(self):
  735.         """Return the formatted long description.
  736.  
  737.         Return the formated long description according to the Debian policy
  738.         (Chapter 5.6.13).
  739.         See http://www.debian.org/doc/debian-policy/ch-controlfields.html
  740.         for more information.
  741.         """
  742.         return getattr(self.candidate, "description", None)
  743.  
  744.     @DeprecatedProperty
  745.     def rawDescription(self):
  746.         """return the long description (raw)."""
  747.         return getattr(self.candidate, "raw_description", None)
  748.  
  749.     @DeprecatedProperty
  750.     def candidateRecord(self):
  751.         """Return the Record of the candidate version of the package."""
  752.         return getattr(self.candidate, "record", None)
  753.  
  754.     @DeprecatedProperty
  755.     def installedRecord(self):
  756.         """Return the Record of the candidate version of the package."""
  757.         return getattr(self.installed, 'record', '')
  758.  
  759.     # depcache states
  760.  
  761.     @property
  762.     def markedInstall(self):
  763.         """Return True if the package is marked for install."""
  764.         return self._pcache._depcache.MarkedInstall(self._pkg)
  765.  
  766.     @property
  767.     def markedUpgrade(self):
  768.         """Return True if the package is marked for upgrade."""
  769.         return self._pcache._depcache.MarkedUpgrade(self._pkg)
  770.  
  771.     @property
  772.     def markedDelete(self):
  773.         """Return True if the package is marked for delete."""
  774.         return self._pcache._depcache.MarkedDelete(self._pkg)
  775.  
  776.     @property
  777.     def markedKeep(self):
  778.         """Return True if the package is marked for keep."""
  779.         return self._pcache._depcache.MarkedKeep(self._pkg)
  780.  
  781.     @property
  782.     def markedDowngrade(self):
  783.         """ Package is marked for downgrade """
  784.         return self._pcache._depcache.MarkedDowngrade(self._pkg)
  785.  
  786.     @property
  787.     def markedReinstall(self):
  788.         """Return True if the package is marked for reinstall."""
  789.         return self._pcache._depcache.MarkedReinstall(self._pkg)
  790.  
  791.     @property
  792.     def isInstalled(self):
  793.         """Return True if the package is installed."""
  794.         return (self._pkg.CurrentVer is not None)
  795.  
  796.     @property
  797.     def isUpgradable(self):
  798.         """Return True if the package is upgradable."""
  799.         return (self.isInstalled and
  800.                 self._pcache._depcache.IsUpgradable(self._pkg))
  801.  
  802.     @property
  803.     def isAutoRemovable(self):
  804.         """Return True if the package is no longer required.
  805.  
  806.         If the package has been installed automatically as a dependency of
  807.         another package, and if no packages depend on it anymore, the package
  808.         is no longer required.
  809.         """
  810.         return self.isInstalled and self._pcache._depcache.IsGarbage(self._pkg)
  811.  
  812.     # sizes
  813.  
  814.     @DeprecatedProperty
  815.     def packageSize(self):
  816.         """Return the size of the candidate deb package."""
  817.         return getattr(self.candidate, "size", None)
  818.  
  819.     @DeprecatedProperty
  820.     def installedPackageSize(self):
  821.         """Return the size of the installed deb package."""
  822.         return getattr(self.installed, 'size', 0)
  823.  
  824.     @DeprecatedProperty
  825.     def candidateInstalledSize(self):
  826.         """Return the size of the candidate installed package."""
  827.         return getattr(self.candidate, "installed_size", None)
  828.  
  829.     @DeprecatedProperty
  830.     def installedSize(self):
  831.         """Return the size of the currently installed package."""
  832.         return getattr(self.installed, 'installed_size', 0)
  833.  
  834.     @property
  835.     def installedFiles(self):
  836.         """Return a list of files installed by the package.
  837.  
  838.         Return a list of unicode names of the files which have
  839.         been installed by this package
  840.         """
  841.         path = "/var/lib/dpkg/info/%s.list" % self.name
  842.         try:
  843.             file_list = open(path)
  844.             try:
  845.                 return file_list.read().decode().split("\n")
  846.             finally:
  847.                 file_list.close()
  848.         except EnvironmentError:
  849.             return []
  850.  
  851.     def getChangelog(self, uri=None, cancel_lock=None):
  852.         """
  853.         Download the changelog of the package and return it as unicode
  854.         string.
  855.  
  856.         The parameter `uri` refers to the uri of the changelog file. It may
  857.         contain multiple named variables which will be substitued. These
  858.         variables are (src_section, prefix, src_pkg, src_ver). An example is
  859.         the Ubuntu changelog:
  860.             "http://changelogs.ubuntu.com/changelogs/pool" \\
  861.                 "/%(src_section)s/%(prefix)s/%(src_pkg)s" \\
  862.                 "/%(src_pkg)s_%(src_ver)s/changelog"
  863.  
  864.         The parameter `cancel_lock` refers to an instance of threading.Lock,
  865.         which if set, prevents the download.
  866.         """
  867.         # Return a cached changelog if available
  868.         if self._changelog != "":
  869.             return self._changelog
  870.  
  871.         if uri is None:
  872.             if not self.candidate:
  873.                 pass
  874.             if self.candidate.origins[0].origin == "Debian":
  875.                 uri = "http://packages.debian.org/changelogs/pool" \
  876.                       "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
  877.                       "/%(src_pkg)s_%(src_ver)s/changelog"
  878.             elif self.candidate.origins[0].origin == "Ubuntu":
  879.                 uri = "http://changelogs.ubuntu.com/changelogs/pool" \
  880.                       "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
  881.                       "/%(src_pkg)s_%(src_ver)s/changelog"
  882.             else:
  883.                 return _("The list of changes is not available")
  884.  
  885.         # get the src package name
  886.         src_pkg = self.candidate.source_name
  887.  
  888.         # assume "main" section
  889.         src_section = "main"
  890.         # use the section of the candidate as a starting point
  891.         section = self.candidate.section
  892.  
  893.         # get the source version, start with the binaries version
  894.         bin_ver = self.candidate.version
  895.         src_ver = self.candidate.version
  896.         #print "bin: %s" % binver
  897.         try:
  898.             # FIXME: This try-statement is too long ...
  899.             # try to get the source version of the pkg, this differs
  900.             # for some (e.g. libnspr4 on ubuntu)
  901.             # this feature only works if the correct deb-src are in the
  902.             # sources.list
  903.             # otherwise we fall back to the binary version number
  904.             src_records = apt_pkg.GetPkgSrcRecords()
  905.             src_rec = src_records.Lookup(src_pkg)
  906.             if src_rec:
  907.                 src_ver = src_records.Version
  908.                 #if apt_pkg.VersionCompare(binver, srcver) > 0:
  909.                 #    srcver = binver
  910.                 if not src_ver:
  911.                     src_ver = bin_ver
  912.                 #print "srcver: %s" % src_ver
  913.                 section = src_records.Section
  914.                 #print "srcsect: %s" % section
  915.             else:
  916.                 # fail into the error handler
  917.                 raise SystemError
  918.         except SystemError:
  919.             src_ver = bin_ver
  920.  
  921.         l = section.split("/")
  922.         if len(l) > 1:
  923.             src_section = l[0]
  924.  
  925.         # lib is handled special
  926.         prefix = src_pkg[0]
  927.         if src_pkg.startswith("lib"):
  928.             prefix = "lib" + src_pkg[3]
  929.  
  930.         # stip epoch
  931.         l = src_ver.split(":")
  932.         if len(l) > 1:
  933.             src_ver = "".join(l[1:])
  934.  
  935.         uri = uri % {"src_section": src_section,
  936.                      "prefix": prefix,
  937.                      "src_pkg": src_pkg,
  938.                      "src_ver": src_ver}
  939.  
  940.         timeout = socket.getdefaulttimeout()
  941.  
  942.         # FIXME: when python2.4 vanishes from the archive,
  943.         #        merge this into a single try..finally block (pep 341)
  944.         try:
  945.             try:
  946.                 # Set a timeout for the changelog download
  947.                 socket.setdefaulttimeout(2)
  948.  
  949.                 # Check if the download was canceled
  950.                 if cancel_lock and cancel_lock.isSet():
  951.                     return ""
  952.                 changelog_file = urllib2.urlopen(uri)
  953.                 # do only get the lines that are new
  954.                 changelog = ""
  955.                 regexp = "^%s \((.*)\)(.*)$" % (re.escape(src_pkg))
  956.                 while True:
  957.                     # Check if the download was canceled
  958.                     if cancel_lock and cancel_lock.isSet():
  959.                         return ""
  960.                     # Read changelog line by line
  961.                     line_raw = changelog_file.readline()
  962.                     if line_raw == "":
  963.                         break
  964.                     # The changelog is encoded in utf-8, but since there isn't
  965.                     # any http header, urllib2 seems to treat it as ascii
  966.                     line = line_raw.decode("utf-8")
  967.  
  968.                     #print line.encode('utf-8')
  969.                     match = re.match(regexp, line)
  970.                     if match:
  971.                         # strip epoch from installed version
  972.                         # and from changelog too
  973.                         installed = self.installedVersion
  974.                         if installed and ":" in installed:
  975.                             installed = installed.split(":", 1)[1]
  976.                         changelog_ver = match.group(1)
  977.                         if changelog_ver and ":" in changelog_ver:
  978.                             changelog_ver = changelog_ver.split(":", 1)[1]
  979.                         if (installed and apt_pkg.VersionCompare(changelog_ver,
  980.                                                               installed) <= 0):
  981.                             break
  982.                     # EOF (shouldn't really happen)
  983.                     changelog += line
  984.  
  985.                 # Print an error if we failed to extract a changelog
  986.                 if len(changelog) == 0:
  987.                     changelog = _("The list of changes is not available")
  988.                 self._changelog = changelog
  989.  
  990.             except urllib2.HTTPError:
  991.                 return _("The list of changes is not available yet.\n\n"
  992.                          "Please use http://launchpad.net/ubuntu/+source/%s/"
  993.                          "%s/+changelog\n"
  994.                          "until the changes become available or try again "
  995.                          "later.") % (src_pkg, src_ver)
  996.             except (IOError, httplib.BadStatusLine):
  997.                 return _("Failed to download the list of changes. \nPlease "
  998.                          "check your Internet connection.")
  999.         finally:
  1000.             socket.setdefaulttimeout(timeout)
  1001.         return self._changelog
  1002.  
  1003.     @DeprecatedProperty
  1004.     def candidateOrigin(self):
  1005.         """Return a list of Origin() objects for the candidate version."""
  1006.         return getattr(self.candidate, "origins", None)
  1007.  
  1008.     @property
  1009.     def versions(self):
  1010.         """Return a VersionList() object for all available versions.
  1011.  
  1012.         :since: 0.7.9
  1013.         """
  1014.         return VersionList(self)
  1015.  
  1016.     @property
  1017.     def is_inst_broken(self):
  1018.         """Return True if the to-be-installed package is broken."""
  1019.         return self._pcache._depcache.IsInstBroken(self._pkg)
  1020.  
  1021.     @property
  1022.     def is_now_broken(self):
  1023.         """Return True if the installed package is broken."""
  1024.         return self._pcache._depcache.IsNowBroken(self._pkg)
  1025.  
  1026.     # depcache actions
  1027.  
  1028.     def markKeep(self):
  1029.         """Mark a package for keep."""
  1030.         self._pcache.cachePreChange()
  1031.         self._pcache._depcache.MarkKeep(self._pkg)
  1032.         self._pcache.cachePostChange()
  1033.  
  1034.     def markDelete(self, autoFix=True, purge=False):
  1035.         """Mark a package for install.
  1036.  
  1037.         If autoFix is True, the resolver will be run, trying to fix broken
  1038.         packages. This is the default.
  1039.  
  1040.         If purge is True, remove the configuration files of the package as
  1041.         well. The default is to keep the configuration.
  1042.         """
  1043.         self._pcache.cachePreChange()
  1044.         self._pcache._depcache.MarkDelete(self._pkg, purge)
  1045.         # try to fix broken stuffsta
  1046.         if autoFix and self._pcache._depcache.BrokenCount > 0:
  1047.             Fix = apt_pkg.GetPkgProblemResolver(self._pcache._depcache)
  1048.             Fix.Clear(self._pkg)
  1049.             Fix.Protect(self._pkg)
  1050.             Fix.Remove(self._pkg)
  1051.             Fix.InstallProtect()
  1052.             Fix.Resolve()
  1053.         self._pcache.cachePostChange()
  1054.  
  1055.     def markInstall(self, autoFix=True, autoInst=True, fromUser=True):
  1056.         """Mark a package for install.
  1057.  
  1058.         If autoFix is True, the resolver will be run, trying to fix broken
  1059.         packages. This is the default.
  1060.  
  1061.         If autoInst is True, the dependencies of the packages will be installed
  1062.         automatically. This is the default.
  1063.  
  1064.         If fromUser is True, this package will not be marked as automatically
  1065.         installed. This is the default. Set it to False if you want to be able
  1066.         to remove the package at a later stage if no other package depends on
  1067.         it.
  1068.         """
  1069.         self._pcache.cachePreChange()
  1070.         self._pcache._depcache.MarkInstall(self._pkg, autoInst, fromUser)
  1071.         # try to fix broken stuff
  1072.         if autoFix and self._pcache._depcache.BrokenCount > 0:
  1073.             fixer = apt_pkg.GetPkgProblemResolver(self._pcache._depcache)
  1074.             fixer.Clear(self._pkg)
  1075.             fixer.Protect(self._pkg)
  1076.             fixer.Resolve(True)
  1077.         self._pcache.cachePostChange()
  1078.  
  1079.     def markUpgrade(self):
  1080.         """Mark a package for upgrade."""
  1081.         if self.isUpgradable:
  1082.             fromUser = not self._pcache._depcache.IsAutoInstalled(self._pkg)
  1083.             self.markInstall(fromUser=fromUser)
  1084.         else:
  1085.             # FIXME: we may want to throw a exception here
  1086.             sys.stderr.write(("MarkUpgrade() called on a non-upgrable pkg: "
  1087.                               "'%s'\n") % self._pkg.Name)
  1088.  
  1089.     def commit(self, fprogress, iprogress):
  1090.         """Commit the changes.
  1091.  
  1092.         The parameter `fprogress` refers to a FetchProgress() object, as
  1093.         found in apt.progress.
  1094.  
  1095.         The parameter `iprogress` refers to an InstallProgress() object, as
  1096.         found in apt.progress.
  1097.         """
  1098.         self._pcache._depcache.Commit(fprogress, iprogress)
  1099.  
  1100.  
  1101. def _test():
  1102.     """Self-test."""
  1103.     print "Self-test for the Package modul"
  1104.     import random
  1105.     import apt
  1106.     apt_pkg.init()
  1107.     progress = apt.progress.OpTextProgress()
  1108.     cache = apt.Cache(progress)
  1109.     pkg = cache["apt-utils"]
  1110.     print "Name: %s " % pkg.name
  1111.     print "ID: %s " % pkg.id
  1112.     print "Priority (Candidate): %s " % pkg.candidate.priority
  1113.     print "Priority (Installed): %s " % pkg.installed.priority
  1114.     print "Installed: %s " % pkg.installed.version
  1115.     print "Candidate: %s " % pkg.candidate.version
  1116.     print "CandidateDownloadable: %s" % pkg.candidate.downloadable
  1117.     print "CandidateOrigins: %s" % pkg.candidate.origins
  1118.     print "SourcePkg: %s " % pkg.candidate.source_name
  1119.     print "Section: %s " % pkg.section
  1120.     print "Summary: %s" % pkg.candidate.summary
  1121.     print "Description (formated) :\n%s" % pkg.candidate.description
  1122.     print "Description (unformated):\n%s" % pkg.candidate.raw_description
  1123.     print "InstalledSize: %s " % pkg.candidate.installed_size
  1124.     print "PackageSize: %s " % pkg.candidate.size
  1125.     print "Dependencies: %s" % pkg.installed.dependencies
  1126.     print "Recommends: %s" % pkg.installed.recommends
  1127.     for dep in pkg.candidate.dependencies:
  1128.         print ",".join("%s (%s) (%s) (%s)" % (o.name, o.version, o.relation,
  1129.                         o.preDepend) for o in dep.or_dependencies)
  1130.     print "arch: %s" % pkg.candidate.architecture
  1131.     print "homepage: %s" % pkg.candidate.homepage
  1132.     print "rec: ", pkg.candidate.record
  1133.  
  1134.  
  1135.     print cache["2vcard"].getChangelog()
  1136.     for i in True, False:
  1137.         print "Running install on random upgradable pkgs with AutoFix: %s " % i
  1138.         for pkg in cache:
  1139.             if pkg.isUpgradable:
  1140.                 if random.randint(0, 1) == 1:
  1141.                     pkg.markInstall(i)
  1142.         print "Broken: %s " % cache._depcache.BrokenCount
  1143.         print "InstCount: %s " % cache._depcache.InstCount
  1144.  
  1145.     print
  1146.     # get a new cache
  1147.     for i in True, False:
  1148.         print "Randomly remove some packages with AutoFix: %s" % i
  1149.         cache = apt.Cache(progress)
  1150.         for name in cache.keys():
  1151.             if random.randint(0, 1) == 1:
  1152.                 try:
  1153.                     cache[name].markDelete(i)
  1154.                 except SystemError:
  1155.                     print "Error trying to remove: %s " % name
  1156.         print "Broken: %s " % cache._depcache.BrokenCount
  1157.         print "DelCount: %s " % cache._depcache.DelCount
  1158.  
  1159. # self-test
  1160. if __name__ == "__main__":
  1161.     _test()
  1162.